FEXPElement.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Definitions of applied finite elements
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPELEMENT_H_
#define _CFEXPELEMENT_H_
#include "FEXPCommon.h"
#include "FEXPGeom.h"
#include "FEXPMaterial.h"
#include "FEXPSetting.h"
#include "FEXPDataContainer.h"

#define FE_NODE_BASE_VECT_LENGTH 6 

enum EFEXPElementForce { eInternal, eContact };
enum EFEXPNodeResult { ePos, eDispl, eStrain, eStress };


class ICFEXPGeomAction
{
public:
  virtual ~ICFEXPGeomAction() { }

  // pure virtual member functions 
  virtual void CalculateTransformation() = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class CFEXPElementNodeTableDataBase
{
public:
  CFEXPElementNodeTableDataBase() { }
  virtual ~CFEXPElementNodeTableDataBase() { }
protected:
  void add_table_data(FEXPFEGeom::EFEXPFECoordinates dir, size_t type, size_t state, t_fexpcommon_ct time, t_fexpcommon_ct value);
  bool get_table_data(FEXPFEGeom::EFEXPFECoordinates dir, size_t type, t_fexpcommon_ct time, size_t & state, t_fexpcommon_ct & value);
  struct table_row_values
  {
    t_fexpcommon_ct _time;
    t_fexpcommon_ct _x;
    t_fexpcommon_ct _y;
    t_fexpcommon_ct _z;
    size_t     _state_x;
    size_t     _state_y;
    size_t     _state_z;
    table_row_values() : _time(FEXPCOMMON_DEFAULT_VALUE),
      _x(FEXPCOMMON_DEFAULT_VALUE), _y(FEXPCOMMON_DEFAULT_VALUE), _z(FEXPCOMMON_DEFAULT_VALUE),
      _state_x(FEXPCOMMON_DEFAULT_VALUE), _state_y(FEXPCOMMON_DEFAULT_VALUE), _state_z(FEXPCOMMON_DEFAULT_VALUE) { }
    void set_value(FEXPFEGeom::EFEXPFECoordinates dir, size_t state, t_fexpcommon_ct value);
    void get_value(FEXPFEGeom::EFEXPFECoordinates dir, size_t & state, t_fexpcommon_ct & value);
  };
  std::map<size_t, Ptr<std::vector<Ptr<table_row_values>>>> _table;
private:
  // [no private members  ] -----------------------------
};


class ICFEXPElementNodeConstrain
  : public CFEXPElementNodeTableDataBase
{
public:
  enum EConstrType { eVel, eVelRot, eAcc, eAccRot };
  enum EConstrStat { eOff, eOn };
  ICFEXPElementNodeConstrain(size_t id) : _id(id) { }
  virtual ~ICFEXPElementNodeConstrain() { }

  size_t GetConstrainId  () { return _id; }
  void   AddConstrainData(FEXPFEGeom::EFEXPFECoordinates dir, EConstrType type, EConstrStat state,
    t_fexpcommon_ct time, t_fexpcommon_ct cstr) { add_table_data(dir, type, state, time, cstr); }

  // pure virtual functions 
  virtual void ApplyConstrain(EConstrType type, Ptr<CFEXPMatrix2D> & vect, t_fexpcommon_ct time) = 0;
protected:
  // [no private members  ] -----------------------------
private:
  size_t _id;
};


class CFEXPElementNodeConstrain
  : public ICFEXPElementNodeConstrain, public ICFEXPModelDataIntf
{
public:
  CFEXPElementNodeConstrain(size_t id);
  virtual ~CFEXPElementNodeConstrain() { }
  // override pure virtual base functions 
  virtual size_t GetId          ()          override { return GetConstrainId();                       }
  virtual size_t GetModelId     ()          override { return FEXPCOMMON_DEFAULT_VALUE;               }
  virtual size_t GetType        ()          override { return size_t(ESystemElementType::eConstrain); }
  virtual size_t GetThreadId    ()          override { return FEXPCOMMON_DEFAULT_VALUE;               }
  virtual size_t GetThreadNumber()          override { return FEXPCOMMON_DEFAULT_VALUE;               }
  virtual void   SetThreadId    (size_t id) override { }
  // override pure virtual base functions -- constrain base
  virtual void ApplyConstrain(EConstrType type, Ptr<CFEXPMatrix2D> & vect, t_fexpcommon_ct time) override;

  // override pure virtual base functions for NETWORK serialization/deserialization
  virtual Ptr<t_SerializedData> NetSerialize  ()                           override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
  virtual void                  NetDeserialize(Ptr<t_SerializedData> data) override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class ICFEXPElementNodeLoad
  : public CFEXPElementNodeTableDataBase
{
public:
  enum ELoadType { eF, eM, eAcc, eAccRot };
  enum ELoadStat { eOff, eOn };
  ICFEXPElementNodeLoad(size_t id) : _id(id) { }
  virtual ~ICFEXPElementNodeLoad() { }

  size_t GetLoadId  () { return _id; }
  void   AddLoadData(FEXPFEGeom::EFEXPFECoordinates dir, ELoadType type, ELoadStat state,
    t_fexpcommon_ct time, t_fexpcommon_ct cstr) { add_table_data(dir, type, state, time, cstr); }

  // pure virtual functions 
  virtual void ApplyLoad(ELoadType type, Ptr<CFEXPMatrix2D> & vect, t_fexpcommon_ct time) = 0;
protected:
  // [no private members  ] -----------------------------
private:
  size_t _id;
};


class CFEXPElementNodeLoad
  : public ICFEXPElementNodeLoad, public ICFEXPModelDataIntf
{
public:
  CFEXPElementNodeLoad(size_t id);
  virtual ~CFEXPElementNodeLoad() { }
  // override pure virtual base functions 
  virtual size_t GetId          ()          override { return GetLoadId();                       }
  virtual size_t GetModelId     ()          override { return FEXPCOMMON_DEFAULT_VALUE;          }
  virtual size_t GetType        ()          override { return size_t(ESystemElementType::eLoad); }
  virtual size_t GetThreadId    ()          override { return FEXPCOMMON_DEFAULT_VALUE;          }
  virtual size_t GetThreadNumber()          override { return FEXPCOMMON_DEFAULT_VALUE;          }
  virtual void   SetThreadId    (size_t id) override { }
  // override pure virtual base functions -- load base
  virtual void ApplyLoad(ELoadType type, Ptr<CFEXPMatrix2D> & vect, t_fexpcommon_ct time);

  // override pure virtual base functions for NETWORK serialization/deserialization
  virtual Ptr<t_SerializedData> NetSerialize  ()                           override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
  virtual void                  NetDeserialize(Ptr<t_SerializedData> data) override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// primary template
template<typename TValue, typename Enable = void>
class ICFEXPElementNodeInitAction { };
template<typename TValue>
class ICFEXPElementNodeInitAction
  // specialization for floating point types
  <TValue, typename std::enable_if<std::is_floating_point<TValue>::value>::type>
{
public:
  virtual ~ICFEXPElementNodeInitAction() { }

  // pure virtual member functions 
  // initialization constrains
  virtual void InitConstrain(Ptr<ICFEXPElementNodeConstrain> & constrain_v,
                             Ptr<ICFEXPElementNodeConstrain> & constrain_a) = 0;
  // initialization loads
  virtual void InitLoad     (Ptr<ICFEXPElementNodeLoad> & load)             = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

class ICFEXPElementBase;
class ICFEXPElementNodeBase
  : public ICFEXPModelDataIntf, public ICFEXPElementNodeInitAction<t_fexpcommon_ct>,
    public CFEXPFECoordinates<t_fexpcommon_ct>
{
public:
  ICFEXPElementNodeBase(size_t id, size_t model_id, t_fexpcommon_ct x, t_fexpcommon_ct y, t_fexpcommon_ct z);
  ICFEXPElementNodeBase(const CFEXPFECoordinates<t_fexpcommon_ct> & source);
  virtual ~ICFEXPElementNodeBase() { }

  // override model element base virtual functions
  virtual size_t GetId      ()          override { return GetNodeId();                       }
  virtual size_t GetModelId ()          override { return _model_id;                         }
  virtual size_t GetType    ()          override { return size_t(ESystemElementType::eNode); }
  virtual size_t GetThreadId()          override { return _thread_id;                        }
  virtual void   SetThreadId(size_t id) override { _thread_id = id;                          }
  void SetAssocElement(Ptr<ICFEXPElementBase> & elem);
  Ptr<std::vector<std::weak_ptr<ICFEXPElementBase>>> GetAssocElements();

  // reset internal and contact forces
  virtual void SetForcesToDefault() = 0;

  // virtual member functions
  virtual void               SetMass(t_fexpcommon_ct mass) { _node_mass = mass; }
  virtual t_fexpcommon_ct    GetMass()                     { return _node_mass; }
  virtual Ptr<CFEXPMatrix2D> GetInrt() { return _inrt_mtrx; }
  // pure virtual member functions
  virtual t_fexpcommon_ct GetOriginalCoordinate(size_t idx) = 0;
  // pure virtual member function -- forces from element
  virtual t_fexpcommon_ct GetForce(EFEXPElementForce force, size_t idx) = 0;
  // pure virtual member function -- reaction force from contact
  virtual t_fexpcommon_ct GetPentratingContactForce(size_t idx)                        = 0;
  virtual void            SetPentratingContactForce(size_t idx, t_fexpcommon_ct force) = 0;
  // pure virtual member function -- explicit calculation of a new displacements
  virtual void CalcNewPosition(t_fexpcommon_ct dt, t_fexpcommon_ct dt_old) = 0;
  // node result
  virtual Ptr<std::map<std::string, std::string>> GetResult() = 0;
  // node displacement
  virtual t_fexpcommon_ct GetDisplacement(FEXPFEGeom::EFEXPFECoordinates dir) = 0;
  // time functions
  size_t          GetTimeStepCounter() { return _t_counter;          }
  bool            GetIsTimeToSaveRes() { return _print_result;       }
  bool            GetIsSimulationEnd() { return _t_current > _t_end; }
  t_fexpcommon_ct GetCurrentTime    () { return _t_current;          }
protected:
  size_t          _thread_id;
  size_t          _model_id;
  // data for time management
  size_t          _t_counter;
  t_fexpcommon_ct _t_current;
  t_fexpcommon_ct _t_end;
  bool            _print_result;
private:
  std::map<size_t, std::weak_ptr<ICFEXPElementBase>> _elements;
  t_fexpcommon_ct                                    _node_mass;
  Ptr<CFEXPMatrix2D>                                 _inrt_mtrx;
};

// primary template
template<typename TValue, typename Enable = void>
class ICFEXPElementCalcAction { };
template<typename TValue>
class ICFEXPElementCalcAction
  // specialization for floating point types
  <TValue, typename std::enable_if<std::is_floating_point<TValue>::value>::type>
{
public:
  virtual ~ICFEXPElementCalcAction() { }

  // reset internal and contact forces
  virtual void SetForcesToDefault() = 0;

  // pure virtual member functions
  // forces
  virtual void CalcIntForce() = 0;
  virtual void CalcConForce(std::vector<Ptr<ICFEXPElementNodeBase>> & found_nodes) = 0;

  // strain and stress
  virtual void CalcStress(t_fexpcommon_ct dt) = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

class ICFEXPElementNodeBase;
// primary template
template<typename TValue, typename Enable = void>
class ICFEXPElementInitAction { };
template<typename TValue>
class ICFEXPElementInitAction
  // specialization for floating point types
  <TValue, typename std::enable_if<std::is_floating_point<TValue>::value>::type>
{
public:
  virtual ~ICFEXPElementInitAction() { }

  // pure virtual member functions 
  // initialization 
  virtual void Init(size_t id, size_t model_id, std::vector<Ptr<ICFEXPElementNodeBase>> & nodes, Ptr<ICFEXPMaterialBase> material,
    Ptr<CFEXPBaseSetting> setting)                            = 0;
  virtual void Init(size_t id, size_t model_id, std::vector<Ptr<ICFEXPElementNodeBase>> & nodes, Ptr<ICFEXPMaterialBase> material,
    Ptr<CFEXPBaseSetting> setting, t_fexpcommon_ct thickness) = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class ICFEXPElementBase
  : public ICFEXPModelDataIntf, public ICFEXPElementInitAction<t_fexpcommon_ct>,
    public ICFEXPElementCalcAction<t_fexpcommon_ct>, 
    public ICFEXPGeomAction
{
public:
  ICFEXPElementBase(FEXPFEDefinition::EFEXPFiniteElementGeom egeom);
  virtual ~ICFEXPElementBase() { }

  // override model element base virtual functions
  virtual size_t GetId      ()          override { return GetElementId();                       }
  virtual size_t GetModelId ()          override { return _fe_model_id;                         }
  virtual size_t GetType    ()          override { return size_t(ESystemElementType::eElement); }
  virtual size_t GetThreadId()          override { return _thread_id;                           }
  virtual void   SetThreadId(size_t id) override { _thread_id = id;                             }

  FEXPFEDefinition::EFEXPFiniteElementGeom GetElementGeom() { return _eFEGeom; }

  size_t GetElementId() const { return _fe_id;       }
  size_t GetNodeCount() const { return _fe_nd_count; }
  std::vector<std::weak_ptr<ICFEXPElementNodeBase>> & GetNodes() { return _node_coord; }

  // it gives values for element bounding box
  Ptr<CFEXGeomTools::t_BoundBox> GetBoundingBoxBounds();

  // forces
  virtual void            SetForce(EFEXPElementForce force, size_t node_id, size_t idx, t_fexpcommon_ct value) = 0;
  virtual t_fexpcommon_ct GetForce(EFEXPElementForce force, size_t node_id, size_t idx)                        = 0;
  // time service
  virtual size_t          GetTimeStepCounter() = 0;
  virtual t_fexpcommon_ct GetCriticalDt     () = 0;
  // element result
  virtual Ptr<std::map<std::string, std::string>> GetResult() = 0;
protected:
  size_t _fe_model_id;
  size_t _fe_id;
  size_t _fe_nd_count;
  Ptr<CFEX3DPlane<t_fexpcommon_ct>>
  get_element_plane(Ptr<ICFEXPElementNodeBase> nd1,
                    Ptr<ICFEXPElementNodeBase> nd2,
                    Ptr<ICFEXPElementNodeBase> nd3);
  // finite element nodes
  std::vector<std::weak_ptr<ICFEXPElementNodeBase>> _node_coord;

  template<typename TFeNode>
  static typename std::enable_if<std::is_base_of<ICFEXPElementNodeBase, TFeNode>::value, Ptr<TFeNode>>::type
  get_specific_fe_node(Ptr<ICFEXPElementNodeBase> base);
private:
  size_t                                   _thread_id;
  FEXPFEDefinition::EFEXPFiniteElementGeom _eFEGeom;
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TFeNode>
typename std::enable_if<std::is_base_of<ICFEXPElementNodeBase, TFeNode>::value, Ptr<TFeNode>>::type
ICFEXPElementBase::get_specific_fe_node(Ptr<ICFEXPElementNodeBase> base)
//--------------------------------------------------------------------------------------
{
  return FEXPCOMMON_STACAST(ICFEXPElementNodeBase, TFeNode, base);
}


class CFEXPElementNodeGeneral
  : public ICFEXPElementNodeBase
{
public:
  CFEXPElementNodeGeneral(size_t id, size_t model_id, t_fexpcommon_ct x, t_fexpcommon_ct y, t_fexpcommon_ct z,
    Ptr<CFEXPBaseSetting> setting);
  virtual ~CFEXPElementNodeGeneral() { }

  virtual size_t GetThreadNumber() override { return _setting->GetThreadNumber(); }

  // reset internal and contact forces
  virtual void SetForcesToDefault() override;

  // override init constrain function
  virtual void InitConstrain(Ptr<ICFEXPElementNodeConstrain> & constrain_v,
                             Ptr<ICFEXPElementNodeConstrain> & constrain_a) override;
  // override init load function
  virtual void InitLoad(Ptr<ICFEXPElementNodeLoad> & load) override;
  // override base virtual functions
  virtual t_fexpcommon_ct GetOriginalCoordinate(size_t idx) override;
  // internal forces
  virtual t_fexpcommon_ct GetForce(EFEXPElementForce force, size_t idx) override;
  // contact forces
  virtual t_fexpcommon_ct GetPentratingContactForce(size_t idx)                        override;
  virtual void            SetPentratingContactForce(size_t idx, t_fexpcommon_ct force) override;
  // new displacement calculation
  virtual void CalcNewPosition(t_fexpcommon_ct dt, t_fexpcommon_ct dt_old) override;
  // node result
  virtual Ptr<std::map<std::string, std::string>> GetResult() override;
  // node displacement
  virtual t_fexpcommon_ct GetDisplacement(FEXPFEGeom::EFEXPFECoordinates dir) override;

  // override pure virtual base functions for NETWORK serialization/deserialization
  virtual Ptr<t_SerializedData> NetSerialize  ()                           override;
  virtual void                  NetDeserialize(Ptr<t_SerializedData> data) override;

  // additional node informations
  // velocities
  Ptr<CFEXPMatrix2D> & GetVeloc() { return _velocity; }
  // accelerations
  Ptr<CFEXPMatrix2D> & GetAccel() { return _acclerat; }
protected:
  // application of constrains
  void apply_acc_constrains(Ptr<CFEXPMatrix2D> & acc);
  void apply_vel_constrains(Ptr<CFEXPMatrix2D> & vel);
  // application of loads
  void apply_frc_load(Ptr<CFEXPMatrix2D> & frc);
  void apply_acc_load(Ptr<CFEXPMatrix2D> & acc);
private:
  Ptr<CFEXPBaseSetting> _setting;
  // current displacements
  Ptr<CFEXPMatrix2D> _displace;
  // current velocities values
  Ptr<CFEXPMatrix2D> _velocity;
  // current accelerations values
  Ptr<CFEXPMatrix2D> _acclerat;
  // initial position vector
  Ptr<CFEXPMatrix2D> _position_orig;
  // current position vector
  Ptr<CFEXPMatrix2D> _position;
  // constrains
  Ptr<ICFEXPElementNodeConstrain> _constrain_v;
  Ptr<ICFEXPElementNodeConstrain> _constrain_a;
  // loads
  Ptr<ICFEXPElementNodeLoad>      _load;
  // node penetrating force                 
  Ptr<CFEXPMatrix2D>              _penetrating_contact_force;
  // integration vectors
  enum EExplicitIntegrVect { eCurrent, eOld };
  std::map<EExplicitIntegrVect, Ptr<CFEXPMatrix2D>> _u;
  std::map<EExplicitIntegrVect, Ptr<CFEXPMatrix2D>> _F_int;
  std::map<EExplicitIntegrVect, Ptr<CFEXPMatrix2D>> _F_ext;
  std::map<EExplicitIntegrVect, Ptr<CFEXPMatrix2D>> _F_cnt;
  // current energies
  t_fexpcommon_ct _En_int;
  t_fexpcommon_ct _En_ext;
  t_fexpcommon_ct _En_cnt;
  // result map id
  std::map<std::string, std::function<std::string()>> _result_map_gttr;
};


class CFEXPElementShellTriag
  : public ICFEXPElementBase
{
public:
  CFEXPElementShellTriag();
  virtual ~CFEXPElementShellTriag() { }

  virtual size_t GetThreadNumber() override { return _setting->GetThreadNumber(); }

  // override init actions
  virtual void Init(size_t id, size_t model_id, std::vector<Ptr<ICFEXPElementNodeBase>> & nodes, Ptr<ICFEXPMaterialBase> material, Ptr<CFEXPBaseSetting> setting)                                        override;
  virtual void Init(size_t id, size_t model_id, std::vector<Ptr<ICFEXPElementNodeBase>> & nodes, Ptr<ICFEXPMaterialBase> material, Ptr<CFEXPBaseSetting> setting, t_fexpcommon_ct thickness) override;

  virtual void SetForcesToDefault() override;

  // override force. calc. actions
  virtual void CalcIntForce() override;
  virtual void CalcConForce(std::vector<Ptr<ICFEXPElementNodeBase>> & found_nodes) override;
  // override base virtual functions -- internal forces, moments
  virtual void            SetForce(EFEXPElementForce force, size_t node_id, size_t idx, t_fexpcommon_ct value) override;
  virtual t_fexpcommon_ct GetForce(EFEXPElementForce force, size_t node_id, size_t idx)                        override;
  // override base virtual functions -- time counter, stabil time step
  virtual size_t          GetTimeStepCounter() override;
  virtual t_fexpcommon_ct GetCriticalDt     () override;

  // override strain and stress calc actions
  virtual void CalcStress(t_fexpcommon_ct dt) override;

  // override geometry update function
  virtual void CalculateTransformation() override;
  // override element result getter
  virtual Ptr<std::map<std::string, std::string>> GetResult() override;

  // override pure virtual base functions for NETWORK serialization/deserialization
  virtual Ptr<t_SerializedData> NetSerialize  ()                           override;
  virtual void                  NetDeserialize(Ptr<t_SerializedData> data) override;

  static const FEXPFEDefinition::EFEXPFiniteElementType ID;
  static const FEXPFEDefinition::EFEXPFiniteElementGeom G_TYPE;
protected:
  // [no protected members] -----------------------------
private:
  // base setting
  Ptr<CFEXPBaseSetting> _setting;

  t_fexpcommon_ct _contact_critical_dt;
  t_fexpcommon_ct _thickness_init;
  t_fexpcommon_ct _thickness_old;
  t_fexpcommon_ct _thickness;
  t_fexpcommon_ct _fe_area;
  size_t          _layer_number;
  void init_shell_layers(t_fexpcommon_ct thick);
  // shell integration h-layers
  std::vector<t_fexpcommon_ct> _fe_int_weight;
  std::vector<t_fexpcommon_ct> _fe_int_layers;
  // nodes of finite element
  enum EShellNodeIndex { eNode1, eNode2, eNode3, eNodeCount };
  // base vectors of local coordinate system (plane definition)
  Ptr<CFEX3DPlane<t_fexpcommon_ct>>    _fe_plane;
  // used material -- layers
  std::vector<Ptr<ICFEXPMaterialBase>> _material;
  bool is_material_valid(size_t layer);

  // data preparation for stress-strain calculation
  void prepare_data_for_stress_strain_calc();
  Ptr<CFEXPMatrix2D> _p_vect;
  Ptr<CFEXPMatrix2D> _p_vect_0;
  Ptr<CFEXPMatrix2D> _v_vect;
  Ptr<CFEXPMatrix2D> _a_vect;
  Ptr<CFEXPMatrix2D> _A_mtrx;
  // geometrical B matrixes
  void calc_B_strain_matrixes();
  Ptr<CFEXPMatrix2D> _B_m_mtrx; // membrane
  Ptr<CFEXPMatrix2D> _B_b_mtrx; // bending
  Ptr<CFEXPMatrix2D> _B_s_mtrx; // shear
  // extract rigid body rotation
  void rigid_body_rot(Ptr<CFEXPMatrix2D> vect_p, Ptr<CFEXPMatrix2D> vect_v, Ptr<CFEXPMatrix2D> vect_a);
  // calculate rate of strain
  void calc_strain_stress(t_fexpcommon_ct dt);
  // strains
  t_fexpcommon_ct _d_m_x;  t_fexpcommon_ct _kpp_x;
  t_fexpcommon_ct _d_m_y;  t_fexpcommon_ct _kpp_y;
  t_fexpcommon_ct _d_m_xy; t_fexpcommon_ct _kpp_xy;
  std::vector<Ptr<CFEXPMatrix2D>> _strn;
  std::vector<Ptr<CFEXPMatrix2D>> _d_strn;
  std::vector<Ptr<CFEXPMatrix2D>> _stress;
  // check penetration of node to element and calculation of contact forces
  bool            get_if_node_penetrates_element         (Ptr<ICFEXPElementNodeBase> node, t_fexpcommon_ct & distance_out, t_fexpcommon_ct & xsi1, t_fexpcommon_ct & xsi2, t_fexpcommon_ct & xsi3);
  t_fexpcommon_ct calculate_contact_force_from_pentration(Ptr<ICFEXPElementNodeBase> node, t_fexpcommon_ct distance, t_fexpcommon_ct xsi1, t_fexpcommon_ct xsi2, t_fexpcommon_ct xsi3);
  void            calculate_natural_coordinates          (t_fexpcommon_ct x, t_fexpcommon_ct y, t_fexpcommon_ct & xsi1_out, t_fexpcommon_ct & xsi2_out, t_fexpcommon_ct & xsi3_out);
  // integrated internal forces (force, moment)
  std::map<size_t, Ptr<CFEXPMatrix2D>> _f_int;
  // contact forces
  std::map<size_t, Ptr<CFEXPMatrix2D>> _f_cnt;
  // result map id
  std::map<std::string, std::function<std::string()>> _result_map_gttr;
};


const FEXPFEDefinition::EFEXPFiniteElementType FINITE_ELEMENT_SRUCT[FEXPFEDefinition::EFEXPFiniteElementType::eFeCount] =
{
  FEXPFEDefinition::EFEXPFiniteElementType::eNoElement,   // Error --> no element
  FEXPFEDefinition::EFEXPFiniteElementType::eFeShellTriag
};

// structure of input file
#define FINITE_ELEMENT_BLOCK FINITE_ELEMENT_SRUCT
// string key for input model data for each block of file structure
#define FINITE_ELEMENT_KEY_KEY(cls) STRUCT_KEYS(FINITE_ELEMENT_BLOCK, CLS_KEY(cls))
// input model data for each block of file structure
#define FINITE_ELEMENT_CLS(cls, basecls) CLS_MAP_PAIR(FINITE_ELEMENT_BLOCK, cls, basecls)

class CFEXPElementFactory
{
public:
  using t_FElementMap = std::map<FEXPFEDefinition::EFEXPFiniteElementType, std::function<Ptr<ICFEXPElementBase>()>>;
  static const t_FElementMap FINITE_ELEMENT_CLS_MAP;

  static Ptr<ICFEXPElementBase> GetFiniteElement(FEXPFEDefinition::EFEXPFiniteElementType el_type);
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

#endif // !_CFEXPELEMENT_H_